数据结构中的八大排序算法
一、冒泡排序
思想：重复走访过要排序的序列，一次比较两个元素，如果他们的顺序错误就将他们进行交换，一次冒上来的是最小的，其次是第二小。
时间复杂度：O(n^2)
空间复杂度:O(1)
稳定性：稳定
/** * 冒泡排序 * @param disOrderArray * @return */ public static int[] BubbleSort(int[] disOrderArray) { int temp; // 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次（肯定不需和自己比） for(int i=0;i<disOrderArray.length-1;i++) { // 把最小的数交换着"冒泡"的相对的最上边,一次冒上来的是最小的,其次是第二小的. for(int j=disOrderArray.length-1;j>i;j--) { //此处为<时其返回是从小到大排序，>时其返回从大到小 if(disOrderArray[j] < disOrderArray[j-1]) { temp = disOrderArray[j]; disOrderArray[j] = disOrderArray[j-1]; disOrderArray[j-1] = temp; } } } return disOrderArray; }
二、快速排序
思想：通过一趟排序将待排记录分割成两个部分，其中一部分记录关键字均比另一部分记录的关键字小，则可以分别对这两部分关键字继续排序，以达到整个序列有序的目的。
时间复杂度：O(nlogn),最坏的情况下为O(n^2)
空间复杂度：O(1)
稳定性:不稳定
/* * * 快速排序 * * 思想: * 通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小, * 则可以分别对这两部分记录继续进行排序,已达到整个序列有序的目的 * * 本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base * 首先从序列最右边开始找比base小的 * ,如果小,换位置,从而base移到刚才右边(比较时比base小)的位置(记为临时的high位),这样base右边的都比base大 * 然后,从序列的最左边开始找比base大的 * ,如果大,换位置,从而base移动到刚才左边(比较时比base大)的位置(记为临时的low位),这样base左边的都比base小 * * 循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归 */ public static int[] quickSort(int[] arr, int low, int heigh) { if(low < heigh) { int division = partition(arr, low, heigh); quickSort(arr, low, division - 1); quickSort(arr, division + 1, heigh); } return arr; } // 分水岭,基位,左边的都比这个位置小,右边的都大 private static int partition(int[] arr, int low, int heigh) { int base = arr[low]; //用子表的第一个记录做枢轴(分水岭)记录 while (low < heigh) { //更改下面两个while循环中的<=和>=，即可获取到从大到小排列 //从表的两端交替向中间扫描，从小到大排列 while (low < heigh && arr[heigh] >= base) { heigh--; } // 如果高位小于base,base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大 swap(arr, heigh, low); while(low < heigh && arr[low] <= base) { low++; } // 如果低位大有base, swap(arr, heigh, low); } //现在low=heigh return low; } //交换大小 private static void swap(int[] arr, int heigh, int low) { int temp = arr[heigh]; arr[heigh] = arr[low]; arr[low] = temp; }
三、直接选择排序:
思想：每一趟排序将会选择出最小的(或者最大的)值，顺序放在已排好序的数列的后面
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定
/** * 直接选择排序 * 直接选择排序每一趟选择出最小的值 * @param arr * @return */ public static int[] selectionSort(int[] arr) { for(int i=0;i<arr.length;i++) { for(int j=i+1;j<arr.length;j++) { if(arr[i] > arr[j]) { int temp = arr[j]; arr[j] = arr[i]; arr[i] = temp; } } } return arr; }
四、堆排序
思想：堆排序利用这种堆这种数据结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素
时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定
/** * 堆排序 * 堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。 * @param arr * @return */ public static int[] heapSort(int[] arr) { int i; // 将arr构成一个大顶堆 // 从 0 到 arr.length/2 ,这些都是有孩子的节点 // 没孩子的节点构造大顶堆就无意义了 for (i = arr.length / 2; i >= 0; i--) { heapAdjust(arr, i, arr.length - 1); } for (i = arr.length - 1; i > 0; i--) { swap(arr, 0, i); // 将arr[0...i-1] 重新构造成一个大顶堆 heapAdjust(arr, 0, i - 1); } return arr; } private static void heapAdjust(int[] arr, int s, int m) { int temp, j; temp = arr[s]; // 指向临时(相对与root节点)的根节点 for (j = 2 * s; j <= m; j *= 2) { // 如果右节点比左节点大,当前节点移到右节点 if (j < m && arr[j] < arr[j + 1]) { // 指向右节点 j++; } // 当前的父节点大于现在指向的节点 // 不需要做任何处理 if (temp >= arr[j]) { break; } // 当前的父节点小于其下的子节点 // 换位置,把这个子节点替换到父节点 // 当前这个位置,如果是叶子节点,则它应该是最小的(相对于它的祖先们) // 这个方法目的就是交换parent与children的值,构造大根堆 // 执行到这里表明当前节点的父节点(临时根节点小于当前的节点), // 把当前节点移到上面,换位置 // arr[s]被覆盖无所谓,因为temp记了这个值(原来的根节点(相对的parent)) arr[s] = arr[j]; // 现在把当前的这个元素,看做是临时的parent节点 // 为了找到此时这个元素的孩子节点,看看是否有比当前这个值还大的 // 最后s指向 当前遍历到的这个元素 s = j; } arr[s] = temp; }
五、插入排序
思想：将一个记录插入到一个已排好序的有序表中，从而得到一个新的、记录增1的有序表。默认将第一个元素看为有序表，然后依次插入后边的元素
注意：这里插入元素的时候默认的策略是从后向前看，找第一个比自己小的；而不是从前向后看，找第一个比自己大的
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定
/** * 插入排序 * 思想:将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表， * 默认将第一个元素看为有序表，一次插入后边的所欲元素 * 时间复杂度O(n^2) * 空间复杂度O(1) 适用于记录数量小的 * @param arr * @return */ public static int[] InsertSort(int[] arr) { //从小到大排列 for(int i=1;i<arr.length;i++) { //待插入元素 int temp = arr[i]; int j; for(j=i-1;j>=0 && temp < arr[j];j--) { //待插入元素小于已有的，就将已有往后挪，直到元素大于插入元素或已经到序列最首端了 arr[j+1] = arr[j]; } arr[j+1] = temp; } return arr; }
六、折半插入排序
思想：折半插入排序是基于直接插入排序进行改写的，其可以减少"移动"和"比较"的次数
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定
/** * 折半插入排序 * 优点:可以减少"比较"和"移动"的次数 * @param arr * @return */ public static int[] BInsertSort(int[] arr){ for(int i=1;i<arr.length;i++) { //待插入元素 int temp = arr[i]; int j; int low = 0, high = i-1; while(low <= high) //在arr[low..high]中折半查找有序插入的位置 { int m = (low + high)/2;//折半 if(temp < arr[m]) { high = m-1; //插入点在低半区 } else { low = m+1; //插入点在高半区 } } //记录后移 for(j=i-1;j>=high+1;j--) { arr[j+1] = arr[j]; } arr[j+1] = temp; } return arr; }
七、希尔排序：
思想：希尔排序也是插入排序的一种，是直接针对插入排序进行改进的，该方法又称为"缩小增量排序"。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定
/** * 希尔排序(缩小增量排序) * 希尔排序也是插入排序的一种，只是其有增量，而且最后一次增量必须为1 * @param arr * @return */ public static int[] ShellInsert(int[] arr){ int step = arr.length/2; //取增量 //保证最后一个增量为1 while(step >= 1) { for(int i=step;i<arr.length;i++) { int temp = arr[i]; int j = 0; //根插入排序的区别在这里 for(j=i-step;j>=0 && temp<arr[j];j-=step) { arr[j+step] = arr[j]; } arr[j+step] = temp; } step /= 2; } return arr; }
八、归并排序
思想：归并排序是将两个或两个以上的有序表组合成一个有序表，该算法是采用分治法实现
时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定性：稳定
/** * 归并排序 * 归并排序是将两个或两个以上的有序表组合成一个新的有序表 * 时间复杂度 O(nlog2n) * @param arr * @param tempArray * @param left * @param right * @return */ public static int[] mergeSort(int[] arr, int left,int right) { if (left < right) { // 取分割位置 int middle = (left + right) / 2; // 递归划分数组左序列 mergeSort(arr, left, middle); // 递归划分数组右序列 mergeSort(arr, middle+1, right); //将左数组和右数组进行归并 Merge(arr, left, middle, right); } return arr; } private static void Merge(int[] arr, int left, int middle,int right) { int[] tempArray = new int[arr.length]; int leftEnd = middle; int rightStart = middle+1; // 临时数组的下标 int tempIndex = left; int tmp = left; // 先循环两个区间段都没有结束的情况 while ((left <= leftEnd) && (rightStart <= right)) { // 左边的比右边的小,先插入左边的 if (arr[left] < arr[rightStart]) { tempArray[tempIndex++] = arr[left++]; } else { tempArray[tempIndex++] = arr[rightStart++]; } } // 判断左序列是否结束 while (left <= leftEnd) { tempArray[tempIndex++] = arr[left++]; } // 判断右序列是否结束 while (rightStart <= right) { tempArray[tempIndex++] = arr[rightStart++]; } // 将临时数组中的内容拷贝回原数组中 // （原left-right范围的内容被复制回原数组） while (tmp <= right) { arr[tmp] = tempArray[tmp++]; } }
九、基数排序
思想：基数是按照低位先排序，然后收集；再按高位排序，然后再收集，依次类推，直到最高位。
注:表示关键词分类到radix(基数)个盒子，在关键词为数字时，基数为10，当关键词为字母时，基数为26
时间复杂度：O(n+d)
空间复杂度：O(n)
稳定性：稳定
/** * 基数排序 * @radix 基数 表示 按关键词分类到radix(基数)个盒子 在关键词为数字时，基数为10 * @d 排序元素的位数 * @return */ public static int[] RadixSort(int[] arr, int radix, int d){ //用于暂存元素 int[] temp = new int[arr.length]; //用于计数排序 int[] count = new int[radix]; int divide = 1; for(int i=0;i<d;i++) { System.arraycopy(arr, 0, temp, 0, arr.length); // 重置count数组，开始统计下一个关键字 Arrays.fill(count, 0); // 计算每个待排序数据的子关键字 for(int j=0;j<arr.length;j++) { int tempKey = (temp[j]/divide)%radix; count[tempKey]++; } for(int j=1;j<radix;j++) { count[j] = count[j] + count[j-1]; } // 按子关键字对指定的数据进行排序 for(int j=arr.length-1;j>=0;j--) { int tempKey = (temp[j]/divide)%radix; count[tempKey]--; arr[count[tempKey]] = temp[j]; } divide = divide * radix; } return arr; } public static void main(String[] args) { //基础默认从小到大排列 // int[] disOrderArray = {3,1,5,7,0}; //冒泡排序 // disOrderArray = BubbleSort(disOrderArray); //快速排序 // disOrderArray = quickSort(disOrderArray, 0, disOrderArray.length-1); //直接选择排序 // disOrderArray = selectionSort(disOrderArray); //堆排序 // disOrderArray = heapSort(disOrderArray); //直接插入排序 // disOrderArray = InsertSort(disOrderArray); //折半插入排序(二分查找排序) // disOrderArray = BInsertSort(disOrderArray); //希尔排序 // disOrderArray = ShellInsert(disOrderArray); //归并排序 // disOrderArray = mergeSort(disOrderArray, 0, disOrderArray.length-1); //基数排序 int[] disOrderArray = {3,2,3,2,5,333,45566,2345678,78,990,12,432,56}; disOrderArray = RadixSort(disOrderArray, 10, 7); for(int i=0;i<disOrderArray.length;i++) { System.out.print(disOrderArray[i]+" "); } }
数据结构基本的排序算法基本都全了。
添加一个二分查找算法：类似于折半查找算法
时间复杂度：O(logn)
/** * 二分查找 * @param arr * @param searchnum 待查找元素 * @return */ public static int BSearch(int[] arr, int searchnum){ int low = 0; int high = arr.length-1; while(low<=high) { int m = (low+high)/2; if(searchnum == arr[m]) { return m; } else if(searchnum < arr[m]) { high = m-1; } else { low = m+1; } } return -1; }
参考：http://blog.csdn.net/tan313/article/details/51146170
